home *** CD-ROM | disk | FTP | other *** search
/ BCI NET / BCI NET Dec 94.iso / archives / programming / languages / cleo.lzh / Cleo / source / SYNTAX.C < prev    next >
Encoding:
C/C++ Source or Header  |  1993-01-24  |  12.6 KB  |  400 lines
  1. /***************************************************************************
  2. *   Ce fichier, ainsi que tous les  modules  l'accompagnant, peut et  doit *
  3. * etre  copié GRATUITEMENT à la seule condition expresse de conserver      *
  4. * l'INTEGRALITE  du  Code Source, de  la documentation, et  des fichiers   *
  5. * annexes du package. Ce logiciel est Shareware, veuilez envoyer 100 FF à  *
  6. * l'auteur pour recevoir regulièrement les nouvelles versions.             *
  7. * Toute modification est INTERDITE sans l'autorisation écrite de l'auteur. *
  8. *            Tous droits réservés à M. DIALLO Barrou, Juillet 1992.        *
  9. ***************************************************************************/
  10.  
  11. /* #define debug */
  12. /*************************   Analyseur Syntaxique   ***********************/
  13.  
  14. #ifdef msdos
  15.         #include "include\\cleobis.h"
  16.         #include "include\\libs.h"
  17. #else
  18.         #include "include/cleobis.h"
  19.         #include "include/libs.h"
  20. #endif
  21.  
  22. extern void TraitErreur (char type, int num, int lig, int col);
  23. extern Erreur Erreurs[];
  24. extern Erreur Avertis[];
  25. extern BOOL dismode;
  26. extern int pcpc;
  27. extern int curlg;
  28. extern int curcol;
  29. extern char curtoken[];
  30. extern CONST *symb;
  31. extern CONST *cursymb;
  32. extern VAR *var;
  33. extern VAR *curvar;
  34. extern int NbVar;
  35. extern MY_TYPESID curtokentype;
  36. extern MY_TYPESID lasttokentype;
  37. extern MY_TYPESID facttype;
  38. extern MY_CONST curconst;
  39. extern Entete head;
  40. extern int curtokenid;
  41. extern int lasttokenid;
  42. extern PROG *prg;
  43. extern int *Adress;
  44. extern PROG *curprg;
  45. extern int Nbfct;
  46. extern int curfct, debut;
  47. extern FIELDSTRUCT Field[];
  48. extern FCTLIB *extfct, *curextfct, *curlibfct;
  49.  
  50. void Code( int mnemo, int ope)
  51. {
  52.         PROG *new;
  53.  
  54.         if ( mnemo == ORG)            /*adress=  ADRESSE COURANTE */
  55.                 *(Adress+ope) = pcpc;
  56.         else
  57.         if ( mnemo == LOADORG)            /*adress=  ADRESSE DE DEBUT PRG */
  58.                 *(Adress+ope) = pcpc?pcpc:1;   /* Si l'adr de debut=0 alors la forcer à 1, sinon on boucle */
  59.         else
  60.         {
  61.          if (!(new=(PROG *)calloc(sizeof(PROG),1)))
  62.                 TraitErreur (FATALERROR, MEMCOMPIL, curlg, curcol);
  63.  
  64.         if (prg == NULL)
  65.             {
  66.                 curprg = new;
  67.                 prg = new;
  68.             }
  69.         else
  70.             {
  71.                 curprg->next =new;
  72.                 curprg = new;
  73.             }
  74.         new->operande = ope;
  75.         new->code = mnemo;
  76.         new->next = NULL;
  77.         pcpc++;          /** Incremente le compteur ordinal **/
  78.         head.codesize++;
  79.         }
  80. }
  81.  
  82. void Expr(void)
  83. {
  84.         int id;
  85.         int type1, type2;       /* Pour l'analyse semantique et confrontation de types */
  86.  
  87.  
  88.         Simple_Exp();
  89.         type1 = lasttokentype;        /* sauve le premier type */
  90.     if ( curtokentype == booleen_mt)
  91.         {
  92.             Lexical();
  93.             id = lasttokenid;         /* Prend l'ancien Id */
  94.             Simple_Exp();
  95.             type2 = lasttokentype;   /* sauve le second type */
  96.         }
  97.     else
  98.         TraitErreur(TEXTERROR, NOBOOL, curlg, curcol);
  99.  
  100. /* Compatibilité des types */
  101.         switch (id)        /** Attention cmp de chaine non implementees **/
  102.         {
  103.             case egal_b:
  104.    /*           printf("type1=%d type2=%d\tstr=%d\tconst=%d\n",type1, type2,string_t, conststr_mt); */
  105. if ((type1 == type2 && (type2 == string_t || type2 == conststr_mt)) ||
  106.     type1==string_t && type2==conststr_mt)
  107.                 Code(EQU_STR,0);
  108.              else
  109.                  Code(EQU,0);    break;
  110.                 case pluspetit_b:
  111.                         Code(LT,0);     break;
  112.                 case plusgrand_b:
  113.                         Code(GT,0);     break;
  114.                 case pluspetitegal_b:
  115.                         Code(LE,0);     break;
  116.                 case plusgrandegal_b:
  117.                         Code(GE,0);     break;
  118.                 case different_b:
  119.                         Code(NE,0);     break;
  120.                 case et_b:
  121.                         Code(AND,0);    break;
  122.                 case ou_b:
  123.                         Code(OR,0);     break;
  124.                 case ouex_b:
  125.                         Code(XOR,0);    break;
  126.                 case non_b:
  127.                         Code(NOT,0);    break;
  128.                 case in_b:
  129.                         Code(IN,0);     break;
  130.                 default:
  131.                      printf("*** Erreur ID booleen EXPR \n");
  132.                                                                                                                 End(); exit(); break;
  133.                 }
  134. }
  135.  
  136. void Facteur(void)
  137. {
  138.         int id; /**Pile **/
  139.  
  140.        if ( *curtoken == '(' && curtokentype == separ_mt)
  141.            {
  142.             Lexical();
  143.             Simple_Exp();           /*** Appel recursif ***/
  144.             if ( *curtoken == ')' )
  145.             Lexical();
  146.             else
  147.             TraitErreur(TEXTERROR, NOPF, curlg, curcol);
  148.            }
  149.         else
  150.   {
  151.         if (curtokentype == constchr_mt || curtokentype == constreal_mt ||
  152.                 curtokentype == constint_mt ||  curtokentype == conststr_mt )
  153.           InsConst();
  154.         else
  155.         if (curtokentype == ident_mt)
  156.                 {
  157.               facttype=TestVar( TRUE); /* Met adr in stack, et valeur */
  158.                 }
  159.         else
  160.         if (curtokentype = math_mt)
  161.         {
  162.             id = curtokenid;
  163.             Lexical();
  164.             if ( *curtoken == '(' )
  165.              {
  166.                 Lexical();
  167.                 Simple_Exp();           /*** Appel recursif ***/
  168.                 if ( *curtoken == ')' )
  169.                     Lexical();
  170.                 else
  171.                     TraitErreur(TEXTERROR, NOPF, curlg, curcol);
  172.              }
  173.             else
  174.                TraitErreur( TEXTERROR, NOPO, curlg, curcol);
  175.  
  176.             switch (id)
  177.              {
  178.                 case abs_m:     Code (ABS,0); break;
  179.                 case atan_m:    Code (ATAN, 0); break;
  180.                 case acos_m:    Code (ACOS, 0); break;
  181.                 case asin_m:    Code (ASIN, 0); break;
  182.                 case cosh_m:    Code (COSH, 0); break;
  183.                 case sinh_m:    Code (SINH, 0); break;
  184.                 case tanh_m:    Code (TANH, 0); break;
  185.                 case cos_m:     Code (COS, 0); break;
  186.                 case sin_m:     Code (SIN, 0); break;
  187.                 case tan_m:     Code (TAN, 0); break;
  188.                 case exp_m:     Code (EXP, 0); break;
  189.                 case frac_m:    Code (FRAC, 0); break;
  190.                 case int_m:     Code (INT, 0); break;
  191.                 case ln_m:      Code (LN, 0); break;
  192.                 case sqr_m:     Code (SQR, 0); break;
  193.                 case sqrt_m:    Code (SQRT, 0); break;
  194.  
  195.                 case odd_m:    Code (ODD, 0); break;
  196.                 case even_m:   Code (EVEN, 0); break;
  197.                 case pred_m:   Code (PRED, 0); break;
  198.                 case succ_m:   Code (SUCC, 0); break;
  199.                 case inv_m:    Code (INV, 0); break;
  200.                 case rnd_m:    Code (RND, 0); break;
  201.  
  202. /*                case sizeof_m:    Code (SIZEOF, 0); break;
  203.                 case lenght_m:    Code (LENGHT, 0); break;
  204.                 case round_m:    Code (ROUND, 0); break;
  205.                 case log_m:    Code (LOG, 0); break;
  206.                 case pwroften_m:    Code (PWROFTEN, 0); break;
  207.  
  208.   */
  209.              }
  210.         }
  211.         else
  212.         if (curtokentype == extern_mt)
  213.         {
  214.             id = curtokenid;
  215.             AnalyseExtern();
  216.         }
  217.         else            /** Si ce n'est pas une fct Math, extern **/
  218.           {
  219.             if (*curtoken == '(' )
  220.                 {
  221.                  Lexical();
  222.                  Simple_Exp();   /** Appel recursif **/
  223.                  if ( *curtoken == ')')
  224.                     Lexical();
  225.                  else
  226.                     TraitErreur(TEXTERROR, NOPF, curlg, curcol);
  227.                 }
  228.             else
  229.                 TraitErreur( TEXTERROR, NOPO, curlg, curcol);
  230.           }
  231.   }
  232. }
  233.  
  234. void Terme(void)
  235. {
  236.         int id; /** Pile **/
  237.  
  238.         Facteur();
  239.         while (curtokenid == fois_o || curtokenid == divise_o
  240.                || curtokenid ==  mod_o || curtokenid == et_b
  241.                || curtokenid ==  ouex_b || curtokenid == div_o)
  242.         {
  243.                 id = curtokenid;
  244.                 Lexical();
  245.                 Facteur();
  246.                 switch(id)
  247.                     {
  248.                         case fois_o     :  Code (MULS, 0);break;
  249.                         case divise_o   :  Code (DIVS,0); break;
  250.                         case et_b      :  Code (AND,0); break;
  251.                         case mod_o      :  Code (MOD,0); break;
  252.                         case div_o      :  Code (DIV,0); break;
  253.                         case ouex_b      :  Code (XOR,0); break;
  254.                     }
  255.         }
  256. }
  257.  
  258. void Simple_Exp(void)   /*** Compilation des expressions mathematiques ***/
  259. {
  260.         int id; /**Pile**/
  261.  
  262.         if (curtokenid == plus_o || curtokenid == moins_o)
  263.         {
  264.                 id = curtokenid;        /** sauve la valeur **/
  265.                 Lexical();
  266.                 Terme();
  267.  
  268.                 if (id == moins_o)
  269.                         Code (NEG, 0);
  270.         }
  271.         else
  272.                 Terme();
  273.         while (curtokenid == plus_o || curtokenid == moins_o
  274.                 || curtokenid == ou_b)
  275.         {
  276.                 id= curtokenid;
  277.                 Lexical();
  278.                 Terme();
  279.                 if ( id == plus_o)
  280.                         Code (ADD, 0);
  281.                 else
  282.                 if ( id == ou_b)
  283.                         Code (OR, 0);
  284.                 else
  285.                         Code (SUB, 0);
  286.         }
  287. }
  288.  
  289. void Instruction(void)
  290. {
  291.     switch (curtokenid)
  292.         {
  293.         case begin_f:
  294.             Bloc();   break;   /** Appel recursif **/
  295.         case while_f:
  296.             while_fct();   break;
  297.         case repeat_f:
  298.             repeat_fct();  break;
  299.         case if_f:
  300.             if_fct();      break;
  301.         case read_fio:
  302.             Lexical();
  303.             read_fct();    break;
  304.         case write_fio:
  305.             Lexical();
  306.             write_fct();   break;
  307.         case readln_fio:
  308.             readln_fct();  break;
  309.         case writeln_fio:
  310.             writeln_fct(); break;
  311.         case inclib_fio:
  312.             inclib_fct(TRUE); break;
  313.         case extern_mt:
  314.             AnalyseExtern(); break;
  315.         case ident_mt:
  316.             Assign();      break;
  317.         default:
  318.             if ( curtokenid != end_f && curtokenid !=until_f)
  319.                 {
  320.                 printf("Instruction %d (%s) non reconnue.\n", curtokenid, curtoken);
  321.                 End(); exit();
  322.                }
  323.             break;
  324.        }
  325. }
  326. void Bloc(void)              /* BLOC d'instructions */
  327. {
  328.     if (curtokenid == begin_f)
  329.         {
  330.             Lexical();
  331.             Instruction();     /** Gestion des ordres Pascal **/
  332.  
  333.             while( *curtoken == ';')
  334.                 {
  335.                     Lexical();
  336.                     Instruction();
  337.                 }
  338.             if (curtokenid != end_f )          /* End */
  339.                 TraitErreur( TEXTERROR, NOEND, curlg, curcol);
  340.             else
  341.                 Lexical();
  342.         }
  343.     else
  344.         TraitErreur(TEXTERROR, NOBEGIN, curlg, curcol);
  345. }
  346.  
  347. void BlocFct(void)              /* BLOC d'une Fonction */
  348. {
  349.         if (curtokenid == procedure_f)
  350.                 Procedure();
  351.         if (curtokenid == function_f)
  352.                 Fonction();
  353.  
  354.         if (curtokenid == var_f)
  355.                 Gere_Variable();
  356. if (curfct==0) Code(LOADORG, debut);         /* Marque le debut du prg */
  357.         if (curtokenid == begin_f)
  358.                 {
  359.                         Lexical();
  360.                         Instruction();     /** Gestion des ordres Pascal **/
  361.  
  362.                         while( *curtoken == ';')
  363.                         {
  364.                                 Lexical();
  365.                                 Instruction();
  366.                         }
  367.                         if (curtokenid != end_f )               /* End */
  368.                                 TraitErreur( TEXTERROR, NOEND, curlg, curcol);
  369.                         else
  370.                                 Lexical();
  371.                 }
  372.         else
  373.                 TraitErreur(TEXTERROR, NOBEGIN, curlg, curcol);
  374. }
  375.  
  376. void Compiler(void)
  377. {
  378.     Lexical();
  379.     while (curtokenid == inclib_fio)
  380.         inclib_fct(FALSE);
  381.     if (curtokenid != program_f)
  382.         TraitErreur(TEXTERROR, NOPRG,curlg, curcol);
  383.     Lexical();
  384.     if ( curtokentype != ident_mt )
  385.         TraitErreur(TEXTERROR, NOIDENT,curlg, curcol);
  386.     Lexical();
  387.     if ( *curtoken != ';')
  388.         TraitErreur(TEXTERROR, NOVIRG,curlg, curcol);
  389.     Lexical();
  390.     while (curtokenid == inclib_fio)
  391.         inclib_fct(FALSE);
  392.     Code (BRA, debut);          /* Anticipe un saut au Bloc Principal */
  393.     BlocFct();
  394.     if ( *curtoken != '.')
  395.         TraitErreur(TEXTERROR, NOPOINT, curlg, curcol);
  396.     Code (RTS,0);
  397.     Lexical();
  398.     if (dismode) Dis();
  399.     WriteCode();
  400. }